package com.hivemc.chunker.conversion.encoding.bedrock.base.resolver.identifier.legacy;

import com.hivemc.chunker.conversion.encoding.base.resolver.identifier.state.TypeMapping;
import com.hivemc.chunker.conversion.intermediate.column.chunk.identifier.type.block.states.BlockStateValue;
import com.hivemc.chunker.conversion.intermediate.column.chunk.identifier.type.block.states.vanilla.types.*;

import java.util.ArrayList;
import java.util.List;

/**
 * A list of types which map how the data values should be converted between legacy Bedrock and Chunker.
 */
public class BedrockLegacyStateTypes {
    public static final TypeMapping<Integer, Age_15> AGE_15 = new TypeMapping.Builder<Integer, Age_15>()
            .mapping(0, Age_15._0)
            .mapping(1, Age_15._1)
            .mapping(2, Age_15._2)
            .mapping(3, Age_15._3)
            .mapping(4, Age_15._4)
            .mapping(5, Age_15._5)
            .mapping(6, Age_15._6)
            .mapping(7, Age_15._7)
            .mapping(8, Age_15._8)
            .mapping(9, Age_15._9)
            .mapping(10, Age_15._10)
            .mapping(11, Age_15._11)
            .mapping(12, Age_15._12)
            .mapping(13, Age_15._13)
            .mapping(14, Age_15._14)
            .mapping(15, Age_15._15)
            .build();
    public static final TypeMapping<Integer, Age_25> AGE_15_TO_25 = new TypeMapping.Builder<Integer, Age_25>()
            .mapping(0, Age_25._0)
            .mapping(1, Age_25._1)
            .mapping(2, Age_25._2)
            .mapping(3, Age_25._3)
            .mapping(4, Age_25._4)
            .mapping(5, Age_25._5)
            .mapping(6, Age_25._6)
            .mapping(7, Age_25._7)
            .mapping(8, Age_25._8)
            .mapping(9, Age_25._9)
            .mapping(10, Age_25._10)
            .mapping(11, Age_25._11)
            .mapping(12, Age_25._12)
            .mapping(13, Age_25._13)
            .mapping(14, Age_25._14)
            .mapping(15, Age_25._15)
            .mapping(15, Age_25._16)
            .mapping(15, Age_25._17)
            .mapping(15, Age_25._18)
            .mapping(15, Age_25._19)
            .mapping(15, Age_25._20)
            .mapping(15, Age_25._21)
            .mapping(15, Age_25._22)
            .mapping(15, Age_25._23)
            .mapping(15, Age_25._24)
            .mapping(15, Age_25._25)
            .build();
    public static final TypeMapping<Integer, Age_3> AGE_3 = new TypeMapping.Builder<Integer, Age_3>()
            .mapping(0, Age_3._0)
            .mapping(1, Age_3._1)
            .mapping(2, Age_3._2)
            .mapping(3, Age_3._3)
            .build();
    public static final TypeMapping<Integer, Age_5> AGE_5 = new TypeMapping.Builder<Integer, Age_5>()
            .mapping(0, Age_5._0)
            .mapping(1, Age_5._1)
            .mapping(2, Age_5._2)
            .mapping(3, Age_5._3)
            .mapping(4, Age_5._4)
            .mapping(5, Age_5._5)
            .mapping(6, Age_5._5)
            .mapping(7, Age_5._5)
            .build();
    public static final TypeMapping<Integer, Age_7> AGE_7 = new TypeMapping.Builder<Integer, Age_7>()
            .mapping(0, Age_7._0)
            .mapping(1, Age_7._1)
            .mapping(2, Age_7._2)
            .mapping(3, Age_7._3)
            .mapping(4, Age_7._4)
            .mapping(5, Age_7._5)
            .mapping(6, Age_7._6)
            .mapping(7, Age_7._7)
            .build();
    public static final TypeMapping<Integer, Axis> AXIS = new TypeMapping.Builder<Integer, Axis>()
            .mapping(0, Axis.Y)
            .mapping(1, Axis.X)
            .mapping(2, Axis.Z)
            .mapping(3, Axis.Y)
            .build();
    public static final TypeMapping<Integer, Axis> AXIS_DEPRECATED = new TypeMapping.Builder<Integer, Axis>()
            .mapping(0, Axis.Y)
            .mapping(1, Axis.Y)
            .mapping(2, Axis.Y)
            .mapping(3, Axis.Y)
            .mapping(4, Axis.X)
            .mapping(5, Axis.X)
            .mapping(6, Axis.X)
            .mapping(7, Axis.X)
            .mapping(8, Axis.Z)
            .mapping(9, Axis.Z)
            .mapping(10, Axis.Z)
            .mapping(11, Axis.Z)
            .mapping(12, Axis.Y)
            .mapping(13, Axis.Y)
            .mapping(14, Axis.Y)
            .mapping(15, Axis.Y)
            .build();
    public static final TypeMapping<Integer, AxisHorizontal> AXIS_HORIZONTAL = new TypeMapping.Builder<Integer, AxisHorizontal>()
            .mapping(1, AxisHorizontal.X)
            .mapping(2, AxisHorizontal.Z)
            .mapping(0, AxisHorizontal.X)
            .mapping(3, AxisHorizontal.X)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> BAMBOO = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Age_1._0, BambooLeafSize.NONE, Stage._0))
            .mapping(1, List.of(Age_1._0, BambooLeafSize.NONE, Stage._1))
            .mapping(2, List.of(Age_1._0, BambooLeafSize.SMALL, Stage._0))
            .mapping(3, List.of(Age_1._0, BambooLeafSize.SMALL, Stage._1))
            .mapping(4, List.of(Age_1._0, BambooLeafSize.LARGE, Stage._0))
            .mapping(5, List.of(Age_1._0, BambooLeafSize.LARGE, Stage._1))
            .mapping(6, List.of(Age_1._0, BambooLeafSize.NONE, Stage._0))
            .mapping(7, List.of(Age_1._0, BambooLeafSize.NONE, Stage._1))
            .mapping(8, List.of(Age_1._1, BambooLeafSize.NONE, Stage._0))
            .mapping(9, List.of(Age_1._1, BambooLeafSize.NONE, Stage._1))
            .mapping(10, List.of(Age_1._1, BambooLeafSize.SMALL, Stage._0))
            .mapping(11, List.of(Age_1._1, BambooLeafSize.SMALL, Stage._1))
            .mapping(12, List.of(Age_1._1, BambooLeafSize.LARGE, Stage._0))
            .mapping(13, List.of(Age_1._1, BambooLeafSize.LARGE, Stage._1))
            .mapping(14, List.of(Age_1._1, BambooLeafSize.NONE, Stage._0))
            .mapping(15, List.of(Age_1._1, BambooLeafSize.NONE, Stage._1))
            .build();
    public static final TypeMapping<Integer, Age_1> BAMBOO_SAPLING = new TypeMapping.Builder<Integer, Age_1>()
            .mapping(0, Age_1._0)
            .mapping(1, Age_1._1)
            .mapping(2, Age_1._0)
            .mapping(3, Age_1._1)
            .mapping(4, Age_1._0)
            .mapping(5, Age_1._1)
            .mapping(6, Age_1._0)
            .mapping(7, Age_1._1)
            .mapping(8, Age_1._0)
            .mapping(9, Age_1._1)
            .mapping(10, Age_1._0)
            .mapping(11, Age_1._1)
            .mapping(12, Age_1._0)
            .mapping(13, Age_1._1)
            .mapping(14, Age_1._0)
            .mapping(15, Age_1._1)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> BED = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirectionHorizontal.SOUTH, Bool.FALSE, BedPart.FOOT))
            .mapping(1, List.of(FacingDirectionHorizontal.WEST, Bool.FALSE, BedPart.FOOT))
            .mapping(2, List.of(FacingDirectionHorizontal.NORTH, Bool.FALSE, BedPart.FOOT))
            .mapping(3, List.of(FacingDirectionHorizontal.EAST, Bool.FALSE, BedPart.FOOT))
            .mapping(4, List.of(FacingDirectionHorizontal.SOUTH, Bool.TRUE, BedPart.FOOT))
            .mapping(5, List.of(FacingDirectionHorizontal.WEST, Bool.TRUE, BedPart.FOOT))
            .mapping(6, List.of(FacingDirectionHorizontal.NORTH, Bool.TRUE, BedPart.FOOT))
            .mapping(7, List.of(FacingDirectionHorizontal.EAST, Bool.TRUE, BedPart.FOOT))
            .mapping(8, List.of(FacingDirectionHorizontal.SOUTH, Bool.FALSE, BedPart.HEAD))
            .mapping(9, List.of(FacingDirectionHorizontal.WEST, Bool.FALSE, BedPart.HEAD))
            .mapping(10, List.of(FacingDirectionHorizontal.NORTH, Bool.FALSE, BedPart.HEAD))
            .mapping(11, List.of(FacingDirectionHorizontal.EAST, Bool.FALSE, BedPart.HEAD))
            .mapping(12, List.of(FacingDirectionHorizontal.SOUTH, Bool.TRUE, BedPart.HEAD))
            .mapping(13, List.of(FacingDirectionHorizontal.WEST, Bool.TRUE, BedPart.HEAD))
            .mapping(14, List.of(FacingDirectionHorizontal.NORTH, Bool.TRUE, BedPart.HEAD))
            .mapping(15, List.of(FacingDirectionHorizontal.EAST, Bool.TRUE, BedPart.HEAD))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> BELL = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirectionHorizontal.NORTH, BellAttachmentType.FLOOR))
            .mapping(1, List.of(FacingDirectionHorizontal.EAST, BellAttachmentType.FLOOR))
            .mapping(2, List.of(FacingDirectionHorizontal.SOUTH, BellAttachmentType.FLOOR))
            .mapping(3, List.of(FacingDirectionHorizontal.WEST, BellAttachmentType.FLOOR))
            .mapping(4, List.of(FacingDirectionHorizontal.NORTH, BellAttachmentType.CEILING))
            .mapping(5, List.of(FacingDirectionHorizontal.EAST, BellAttachmentType.CEILING))
            .mapping(6, List.of(FacingDirectionHorizontal.SOUTH, BellAttachmentType.CEILING))
            .mapping(7, List.of(FacingDirectionHorizontal.WEST, BellAttachmentType.CEILING))
            .mapping(8, List.of(FacingDirectionHorizontal.NORTH, BellAttachmentType.SINGLE_WALL))
            .mapping(9, List.of(FacingDirectionHorizontal.EAST, BellAttachmentType.SINGLE_WALL))
            .mapping(10, List.of(FacingDirectionHorizontal.SOUTH, BellAttachmentType.SINGLE_WALL))
            .mapping(11, List.of(FacingDirectionHorizontal.WEST, BellAttachmentType.SINGLE_WALL))
            .mapping(12, List.of(FacingDirectionHorizontal.NORTH, BellAttachmentType.DOUBLE_WALL))
            .mapping(13, List.of(FacingDirectionHorizontal.EAST, BellAttachmentType.DOUBLE_WALL))
            .mapping(14, List.of(FacingDirectionHorizontal.SOUTH, BellAttachmentType.DOUBLE_WALL))
            .mapping(15, List.of(FacingDirectionHorizontal.WEST, BellAttachmentType.DOUBLE_WALL))
            .mapping(16, List.of(FacingDirectionHorizontal.NORTH, BellAttachmentType.FLOOR))
            .mapping(17, List.of(FacingDirectionHorizontal.EAST, BellAttachmentType.FLOOR))
            .mapping(18, List.of(FacingDirectionHorizontal.SOUTH, BellAttachmentType.FLOOR))
            .mapping(19, List.of(FacingDirectionHorizontal.WEST, BellAttachmentType.FLOOR))
            .mapping(20, List.of(FacingDirectionHorizontal.NORTH, BellAttachmentType.CEILING))
            .mapping(21, List.of(FacingDirectionHorizontal.EAST, BellAttachmentType.CEILING))
            .mapping(22, List.of(FacingDirectionHorizontal.SOUTH, BellAttachmentType.CEILING))
            .mapping(23, List.of(FacingDirectionHorizontal.WEST, BellAttachmentType.CEILING))
            .mapping(24, List.of(FacingDirectionHorizontal.NORTH, BellAttachmentType.SINGLE_WALL))
            .mapping(25, List.of(FacingDirectionHorizontal.EAST, BellAttachmentType.SINGLE_WALL))
            .mapping(26, List.of(FacingDirectionHorizontal.SOUTH, BellAttachmentType.SINGLE_WALL))
            .mapping(27, List.of(FacingDirectionHorizontal.WEST, BellAttachmentType.SINGLE_WALL))
            .mapping(28, List.of(FacingDirectionHorizontal.NORTH, BellAttachmentType.DOUBLE_WALL))
            .mapping(29, List.of(FacingDirectionHorizontal.EAST, BellAttachmentType.DOUBLE_WALL))
            .mapping(30, List.of(FacingDirectionHorizontal.SOUTH, BellAttachmentType.DOUBLE_WALL))
            .mapping(31, List.of(FacingDirectionHorizontal.WEST, BellAttachmentType.DOUBLE_WALL))
            .build();
    public static final TypeMapping<Integer, Bites> BITES = new TypeMapping.Builder<Integer, Bites>()
            .mapping(0, Bites._0)
            .mapping(1, Bites._1)
            .mapping(2, Bites._2)
            .mapping(3, Bites._3)
            .mapping(4, Bites._4)
            .mapping(5, Bites._5)
            .mapping(6, Bites._6)
            .mapping(7, Bites._6)
            .build();
    public static final TypeMapping<Integer, Bool> BOOL = new TypeMapping.Builder<Integer, Bool>()
            .mapping(0, Bool.FALSE)
            .mapping(1, Bool.TRUE)
            .build();
    public static final TypeMapping<Integer, Bool> BOOLS_TO_VINE_DIRECTION = new TypeMapping.Builder<Integer, Bool>()
            .generate((builder) -> {
                // Convert south, west, north, east into an integer
                for (int input = 0; input < 16; input++) {
                    List<Bool> output = new ArrayList<>(4);
                    for (int j = 0; j < 4; j++) {
                        output.add(((input >> j) & 1) == 1 ? Bool.TRUE : Bool.FALSE);
                    }
                    builder.mapping(input, output);
                }
            })
            .build();
    public static final TypeMapping<Integer, BlockStateValue> BREWING_STAND = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(1, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(2, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(3, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(4, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(5, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(6, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(7, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, FacingDirectionHorizontal> CARDINAL_DIRECTION_LEGACY = new TypeMapping.Builder<Integer, FacingDirectionHorizontal>()
            .mapping(0, FacingDirectionHorizontal.SOUTH)
            .mapping(1, FacingDirectionHorizontal.WEST)
            .mapping(2, FacingDirectionHorizontal.NORTH)
            .mapping(3, FacingDirectionHorizontal.EAST)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> CARDINAL_DIRECTION_LEGACY_BOOL = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(1, List.of(FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(2, List.of(FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(3, List.of(FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(4, List.of(FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(5, List.of(FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(6, List.of(FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(7, List.of(FacingDirectionHorizontal.EAST, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> CARDINAL_DIRECTION_LEGACY_BOOL_INVERSE = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(1, List.of(FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(2, List.of(FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(3, List.of(FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(4, List.of(FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(5, List.of(FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(6, List.of(FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(7, List.of(FacingDirectionHorizontal.EAST, Bool.FALSE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> COCOA = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirectionHorizontal.SOUTH, Age_2._0))
            .mapping(1, List.of(FacingDirectionHorizontal.WEST, Age_2._0))
            .mapping(2, List.of(FacingDirectionHorizontal.NORTH, Age_2._0))
            .mapping(3, List.of(FacingDirectionHorizontal.EAST, Age_2._0))
            .mapping(4, List.of(FacingDirectionHorizontal.SOUTH, Age_2._1))
            .mapping(5, List.of(FacingDirectionHorizontal.WEST, Age_2._1))
            .mapping(6, List.of(FacingDirectionHorizontal.NORTH, Age_2._1))
            .mapping(7, List.of(FacingDirectionHorizontal.EAST, Age_2._1))
            .mapping(8, List.of(FacingDirectionHorizontal.SOUTH, Age_2._2))
            .mapping(9, List.of(FacingDirectionHorizontal.WEST, Age_2._2))
            .mapping(10, List.of(FacingDirectionHorizontal.NORTH, Age_2._2))
            .mapping(11, List.of(FacingDirectionHorizontal.EAST, Age_2._2))
            .mapping(12, List.of(FacingDirectionHorizontal.SOUTH, Age_2._0))
            .mapping(13, List.of(FacingDirectionHorizontal.WEST, Age_2._0))
            .mapping(14, List.of(FacingDirectionHorizontal.NORTH, Age_2._0))
            .mapping(15, List.of(FacingDirectionHorizontal.EAST, Age_2._0))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> COMPARATOR = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirectionHorizontal.SOUTH, ComparatorMode.COMPARE, Bool.FALSE))
            .mapping(1, List.of(FacingDirectionHorizontal.WEST, ComparatorMode.COMPARE, Bool.FALSE))
            .mapping(2, List.of(FacingDirectionHorizontal.NORTH, ComparatorMode.COMPARE, Bool.FALSE))
            .mapping(3, List.of(FacingDirectionHorizontal.EAST, ComparatorMode.COMPARE, Bool.FALSE))
            .mapping(4, List.of(FacingDirectionHorizontal.SOUTH, ComparatorMode.SUBTRACT, Bool.FALSE))
            .mapping(5, List.of(FacingDirectionHorizontal.WEST, ComparatorMode.SUBTRACT, Bool.FALSE))
            .mapping(6, List.of(FacingDirectionHorizontal.NORTH, ComparatorMode.SUBTRACT, Bool.FALSE))
            .mapping(7, List.of(FacingDirectionHorizontal.EAST, ComparatorMode.SUBTRACT, Bool.FALSE))
            .mapping(8, List.of(FacingDirectionHorizontal.SOUTH, ComparatorMode.COMPARE, Bool.TRUE))
            .mapping(9, List.of(FacingDirectionHorizontal.WEST, ComparatorMode.COMPARE, Bool.TRUE))
            .mapping(10, List.of(FacingDirectionHorizontal.NORTH, ComparatorMode.COMPARE, Bool.TRUE))
            .mapping(11, List.of(FacingDirectionHorizontal.EAST, ComparatorMode.COMPARE, Bool.TRUE))
            .mapping(12, List.of(FacingDirectionHorizontal.SOUTH, ComparatorMode.SUBTRACT, Bool.TRUE))
            .mapping(13, List.of(FacingDirectionHorizontal.WEST, ComparatorMode.SUBTRACT, Bool.TRUE))
            .mapping(14, List.of(FacingDirectionHorizontal.NORTH, ComparatorMode.SUBTRACT, Bool.TRUE))
            .mapping(15, List.of(FacingDirectionHorizontal.EAST, ComparatorMode.SUBTRACT, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, ComposterLevel> COMPOSTER_LEVEL = new TypeMapping.Builder<Integer, ComposterLevel>()
            .mapping(0, ComposterLevel._0)
            .mapping(1, ComposterLevel._1)
            .mapping(2, ComposterLevel._2)
            .mapping(3, ComposterLevel._3)
            .mapping(4, ComposterLevel._4)
            .mapping(5, ComposterLevel._5)
            .mapping(6, ComposterLevel._6)
            .mapping(7, ComposterLevel._7)
            .mapping(8, ComposterLevel._8)
            .mapping(9, ComposterLevel._8)
            .mapping(10, ComposterLevel._8)
            .mapping(11, ComposterLevel._8)
            .mapping(12, ComposterLevel._8)
            .mapping(13, ComposterLevel._8)
            .mapping(14, ComposterLevel._8)
            .mapping(15, ComposterLevel._8)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> DOOR = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(HingeSide.LEFT, Half.BOTTOM, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(1, List.of(HingeSide.RIGHT, Half.BOTTOM, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(2, List.of(HingeSide.LEFT, Half.BOTTOM, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(3, List.of(HingeSide.RIGHT, Half.BOTTOM, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(4, List.of(HingeSide.LEFT, Half.BOTTOM, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(5, List.of(HingeSide.RIGHT, Half.BOTTOM, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(6, List.of(HingeSide.LEFT, Half.BOTTOM, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(7, List.of(HingeSide.RIGHT, Half.BOTTOM, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(8, List.of(HingeSide.LEFT, Half.TOP, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(9, List.of(HingeSide.RIGHT, Half.TOP, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(10, List.of(HingeSide.LEFT, Half.TOP, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(11, List.of(HingeSide.RIGHT, Half.TOP, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(12, List.of(HingeSide.LEFT, Half.TOP, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(13, List.of(HingeSide.RIGHT, Half.TOP, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(14, List.of(HingeSide.LEFT, Half.TOP, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(15, List.of(HingeSide.RIGHT, Half.TOP, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            // These states are duplicates but used to handle any input overflow
            .mapping(16, List.of(HingeSide.LEFT, Half.BOTTOM, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(17, List.of(HingeSide.RIGHT, Half.BOTTOM, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(18, List.of(HingeSide.LEFT, Half.BOTTOM, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(19, List.of(HingeSide.RIGHT, Half.BOTTOM, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(20, List.of(HingeSide.LEFT, Half.BOTTOM, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(21, List.of(HingeSide.RIGHT, Half.BOTTOM, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(22, List.of(HingeSide.LEFT, Half.BOTTOM, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(23, List.of(HingeSide.RIGHT, Half.BOTTOM, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(24, List.of(HingeSide.LEFT, Half.TOP, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(25, List.of(HingeSide.RIGHT, Half.TOP, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(26, List.of(HingeSide.LEFT, Half.TOP, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(27, List.of(HingeSide.RIGHT, Half.TOP, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(28, List.of(HingeSide.LEFT, Half.TOP, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(29, List.of(HingeSide.RIGHT, Half.TOP, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(30, List.of(HingeSide.LEFT, Half.TOP, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(31, List.of(HingeSide.RIGHT, Half.TOP, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            // States which aren't supported but need to be listed, so they go to the right input
            .mapping(0, List.of(HingeSide.RIGHT, Half.BOTTOM, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(1, List.of(HingeSide.LEFT, Half.BOTTOM, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(2, List.of(HingeSide.RIGHT, Half.BOTTOM, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(3, List.of(HingeSide.LEFT, Half.BOTTOM, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(4, List.of(HingeSide.RIGHT, Half.BOTTOM, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(5, List.of(HingeSide.LEFT, Half.BOTTOM, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(6, List.of(HingeSide.RIGHT, Half.BOTTOM, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(7, List.of(HingeSide.LEFT, Half.BOTTOM, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(8, List.of(HingeSide.RIGHT, Half.TOP, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(9, List.of(HingeSide.LEFT, Half.TOP, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(10, List.of(HingeSide.RIGHT, Half.TOP, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(11, List.of(HingeSide.LEFT, Half.TOP, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(12, List.of(HingeSide.RIGHT, Half.TOP, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(13, List.of(HingeSide.LEFT, Half.TOP, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(14, List.of(HingeSide.RIGHT, Half.TOP, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(15, List.of(HingeSide.LEFT, Half.TOP, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> FACING_DIRECTION_BOOL = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirection.DOWN, Bool.FALSE))
            .mapping(1, List.of(FacingDirection.UP, Bool.FALSE))
            .mapping(2, List.of(FacingDirection.NORTH, Bool.FALSE))
            .mapping(3, List.of(FacingDirection.SOUTH, Bool.FALSE))
            .mapping(4, List.of(FacingDirection.WEST, Bool.FALSE))
            .mapping(5, List.of(FacingDirection.EAST, Bool.FALSE))
            .mapping(6, List.of(FacingDirection.DOWN, Bool.FALSE))
            .mapping(7, List.of(FacingDirection.UP, Bool.FALSE))
            .mapping(8, List.of(FacingDirection.DOWN, Bool.TRUE))
            .mapping(9, List.of(FacingDirection.UP, Bool.TRUE))
            .mapping(10, List.of(FacingDirection.NORTH, Bool.TRUE))
            .mapping(11, List.of(FacingDirection.SOUTH, Bool.TRUE))
            .mapping(12, List.of(FacingDirection.WEST, Bool.TRUE))
            .mapping(13, List.of(FacingDirection.EAST, Bool.TRUE))
            .mapping(14, List.of(FacingDirection.DOWN, Bool.TRUE))
            .mapping(15, List.of(FacingDirection.UP, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, FacingDirectionHorizontal> FACING_DIRECTION_LEGACY_HORIZONTAL = new TypeMapping.Builder<Integer, FacingDirectionHorizontal>()
            .mapping(2, FacingDirectionHorizontal.NORTH)
            .mapping(3, FacingDirectionHorizontal.SOUTH)
            .mapping(4, FacingDirectionHorizontal.WEST)
            .mapping(5, FacingDirectionHorizontal.EAST)
            .mapping(0, FacingDirectionHorizontal.NORTH)
            .mapping(1, FacingDirectionHorizontal.NORTH)
            .mapping(6, FacingDirectionHorizontal.NORTH)
            .mapping(7, FacingDirectionHorizontal.NORTH)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> FACING_DIRECTION_LEGACY_HORIZONTAL_BOOL = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(2, FacingDirectionHorizontal.NORTH, Bool.FALSE)
            .mapping(3, FacingDirectionHorizontal.SOUTH, Bool.FALSE)
            .mapping(4, FacingDirectionHorizontal.WEST, Bool.FALSE)
            .mapping(5, FacingDirectionHorizontal.EAST, Bool.FALSE)
            .mapping(0, FacingDirectionHorizontal.NORTH, Bool.FALSE)
            .mapping(1, FacingDirectionHorizontal.NORTH, Bool.FALSE)
            .mapping(6, FacingDirectionHorizontal.NORTH, Bool.FALSE)
            .mapping(7, FacingDirectionHorizontal.NORTH, Bool.FALSE)
            .mapping(10, FacingDirectionHorizontal.NORTH, Bool.TRUE)
            .mapping(11, FacingDirectionHorizontal.SOUTH, Bool.TRUE)
            .mapping(12, FacingDirectionHorizontal.WEST, Bool.TRUE)
            .mapping(13, FacingDirectionHorizontal.EAST, Bool.TRUE)
            .mapping(8, FacingDirectionHorizontal.NORTH, Bool.TRUE)
            .mapping(9, FacingDirectionHorizontal.NORTH, Bool.TRUE)
            .mapping(14, FacingDirectionHorizontal.NORTH, Bool.TRUE)
            .mapping(15, FacingDirectionHorizontal.NORTH, Bool.TRUE)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> FACING_DIRECTION_TO_ATTACHMENT_FACING_DIRECTION = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(AttachmentType.CEILING, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(0, List.of(AttachmentType.CEILING, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(0, List.of(AttachmentType.CEILING, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(0, List.of(AttachmentType.CEILING, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(1, List.of(AttachmentType.FLOOR, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(1, List.of(AttachmentType.FLOOR, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(1, List.of(AttachmentType.FLOOR, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(1, List.of(AttachmentType.FLOOR, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(2, List.of(AttachmentType.WALL, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(3, List.of(AttachmentType.WALL, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(4, List.of(AttachmentType.WALL, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(5, List.of(AttachmentType.WALL, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(6, List.of(AttachmentType.CEILING, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(7, List.of(AttachmentType.CEILING, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(8, List.of(AttachmentType.CEILING, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(8, List.of(AttachmentType.CEILING, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(8, List.of(AttachmentType.CEILING, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(8, List.of(AttachmentType.CEILING, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(9, List.of(AttachmentType.FLOOR, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(9, List.of(AttachmentType.FLOOR, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(9, List.of(AttachmentType.FLOOR, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(9, List.of(AttachmentType.FLOOR, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(10, List.of(AttachmentType.WALL, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(11, List.of(AttachmentType.WALL, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(12, List.of(AttachmentType.WALL, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(13, List.of(AttachmentType.WALL, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(14, List.of(AttachmentType.CEILING, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(15, List.of(AttachmentType.CEILING, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, Orientation> FACING_DIRECTION_TO_ORIENTATION = new TypeMapping.Builder<Integer, Orientation>()
            .mapping(0, Orientation.DOWN_NORTH)
            .mapping(0, Orientation.DOWN_WEST)
            .mapping(0, Orientation.DOWN_SOUTH)
            .mapping(0, Orientation.DOWN_EAST)
            .mapping(1, Orientation.UP_NORTH)
            .mapping(1, Orientation.UP_EAST)
            .mapping(1, Orientation.UP_SOUTH)
            .mapping(1, Orientation.UP_WEST)
            .mapping(2, Orientation.NORTH_UP)
            .mapping(3, Orientation.SOUTH_UP)
            .mapping(4, Orientation.WEST_UP)
            .mapping(5, Orientation.EAST_UP)
            .mapping(6, Orientation.DOWN_NORTH)
            .mapping(7, Orientation.DOWN_NORTH)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> FENCE_GATE = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(1, List.of(Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(2, List.of(Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(3, List.of(Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(4, List.of(Bool.FALSE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(5, List.of(Bool.FALSE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(6, List.of(Bool.FALSE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(7, List.of(Bool.FALSE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(8, List.of(Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(9, List.of(Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(10, List.of(Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(11, List.of(Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(12, List.of(Bool.TRUE, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(13, List.of(Bool.TRUE, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(15, List.of(Bool.TRUE, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, FacingDirection> FLIPPED_FACING_DIRECTION = new TypeMapping.Builder<Integer, FacingDirection>()
            .mapping(0, FacingDirection.DOWN)
            .mapping(1, FacingDirection.UP)
            .mapping(2, FacingDirection.SOUTH)
            .mapping(3, FacingDirection.NORTH)
            .mapping(4, FacingDirection.EAST)
            .mapping(5, FacingDirection.WEST)
            .mapping(6, FacingDirection.DOWN)
            .mapping(7, FacingDirection.UP)
            .build();
    public static final TypeMapping<Integer, LiquidLevel> FLOWING_LEVEL = new TypeMapping.Builder<Integer, LiquidLevel>()
            .mapping(0, LiquidLevel._0)
            .mapping(1, LiquidLevel._1)
            .mapping(2, LiquidLevel._2)
            .mapping(3, LiquidLevel._3)
            .mapping(4, LiquidLevel._4)
            .mapping(5, LiquidLevel._5)
            .mapping(6, LiquidLevel._6)
            .mapping(7, LiquidLevel._7)
            .mapping(8, LiquidLevel._8)
            .mapping(9, LiquidLevel._9)
            .mapping(10, LiquidLevel._10)
            .mapping(11, LiquidLevel._11)
            .mapping(12, LiquidLevel._12)
            .mapping(13, LiquidLevel._13)
            .mapping(14, LiquidLevel._14)
            .mapping(15, LiquidLevel._15)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> FRAME = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, FacingDirection.EAST, Bool.FALSE)
            .mapping(1, FacingDirection.WEST, Bool.FALSE)
            .mapping(2, FacingDirection.SOUTH, Bool.FALSE)
            .mapping(3, FacingDirection.NORTH, Bool.FALSE)
            .mapping(4, FacingDirection.EAST, Bool.TRUE)
            .mapping(5, FacingDirection.WEST, Bool.TRUE)
            .mapping(6, FacingDirection.SOUTH, Bool.TRUE)
            .mapping(7, FacingDirection.NORTH, Bool.TRUE)
            .mapping(0, FacingDirection.UP, Bool.FALSE)
            .mapping(0, FacingDirection.DOWN, Bool.FALSE)
            .mapping(0, FacingDirection.UP, Bool.TRUE)
            .mapping(0, FacingDirection.DOWN, Bool.TRUE)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> GRINDSTONE = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirectionHorizontal.SOUTH, GrindstoneAttachmentType.FLOOR))
            .mapping(1, List.of(FacingDirectionHorizontal.WEST, GrindstoneAttachmentType.FLOOR))
            .mapping(2, List.of(FacingDirectionHorizontal.NORTH, GrindstoneAttachmentType.FLOOR))
            .mapping(3, List.of(FacingDirectionHorizontal.EAST, GrindstoneAttachmentType.FLOOR))
            .mapping(4, List.of(FacingDirectionHorizontal.SOUTH, GrindstoneAttachmentType.CEILING))
            .mapping(5, List.of(FacingDirectionHorizontal.WEST, GrindstoneAttachmentType.CEILING))
            .mapping(6, List.of(FacingDirectionHorizontal.NORTH, GrindstoneAttachmentType.CEILING))
            .mapping(7, List.of(FacingDirectionHorizontal.EAST, GrindstoneAttachmentType.CEILING))
            .mapping(8, List.of(FacingDirectionHorizontal.SOUTH, GrindstoneAttachmentType.WALL))
            .mapping(9, List.of(FacingDirectionHorizontal.WEST, GrindstoneAttachmentType.WALL))
            .mapping(10, List.of(FacingDirectionHorizontal.NORTH, GrindstoneAttachmentType.WALL))
            .mapping(11, List.of(FacingDirectionHorizontal.EAST, GrindstoneAttachmentType.WALL))
            .mapping(12, List.of(FacingDirectionHorizontal.SOUTH, GrindstoneAttachmentType.MULTIPLE))
            .mapping(13, List.of(FacingDirectionHorizontal.WEST, GrindstoneAttachmentType.MULTIPLE))
            .mapping(14, List.of(FacingDirectionHorizontal.NORTH, GrindstoneAttachmentType.MULTIPLE))
            .mapping(15, List.of(FacingDirectionHorizontal.EAST, GrindstoneAttachmentType.MULTIPLE))
            .build();
    public static final TypeMapping<Boolean, Half> HALF = new TypeMapping.Builder<Boolean, Half>()
            .mapping(false, Half.BOTTOM)
            .mapping(true, Half.TOP)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> HOPPER = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirectionHorizontalDown.DOWN, Bool.TRUE))
            .mapping(1, List.of(FacingDirectionHorizontalDown.DOWN, Bool.TRUE))
            .mapping(2, List.of(FacingDirectionHorizontalDown.NORTH, Bool.TRUE))
            .mapping(3, List.of(FacingDirectionHorizontalDown.SOUTH, Bool.TRUE))
            .mapping(4, List.of(FacingDirectionHorizontalDown.WEST, Bool.TRUE))
            .mapping(5, List.of(FacingDirectionHorizontalDown.EAST, Bool.TRUE))
            .mapping(6, List.of(FacingDirectionHorizontalDown.DOWN, Bool.TRUE))
            .mapping(7, List.of(FacingDirectionHorizontalDown.DOWN, Bool.TRUE))
            .mapping(8, List.of(FacingDirectionHorizontalDown.DOWN, Bool.FALSE))
            .mapping(9, List.of(FacingDirectionHorizontalDown.DOWN, Bool.FALSE))
            .mapping(10, List.of(FacingDirectionHorizontalDown.NORTH, Bool.FALSE))
            .mapping(11, List.of(FacingDirectionHorizontalDown.SOUTH, Bool.FALSE))
            .mapping(12, List.of(FacingDirectionHorizontalDown.WEST, Bool.FALSE))
            .mapping(13, List.of(FacingDirectionHorizontalDown.EAST, Bool.FALSE))
            .mapping(14, List.of(FacingDirectionHorizontalDown.DOWN, Bool.FALSE))
            .mapping(15, List.of(FacingDirectionHorizontalDown.DOWN, Bool.FALSE))
            .build();
    public static final TypeMapping<Integer, Layers> LAYERS = new TypeMapping.Builder<Integer, Layers>()
            .mapping(0, Layers._1)
            .mapping(1, Layers._2)
            .mapping(2, Layers._3)
            .mapping(3, Layers._4)
            .mapping(4, Layers._5)
            .mapping(5, Layers._6)
            .mapping(6, Layers._7)
            .mapping(7, Layers._8)
            .mapping(8, Layers._1)
            .mapping(9, Layers._2)
            .mapping(10, Layers._3)
            .mapping(11, Layers._4)
            .mapping(12, Layers._5)
            .mapping(13, Layers._6)
            .mapping(14, Layers._7)
            .mapping(15, Layers._8)
            .build();
    public static final TypeMapping<String, BambooLeafSize> LEAVES = new TypeMapping.Builder<String, BambooLeafSize>()
            .mapping("no_leaves", BambooLeafSize.NONE)
            .mapping("small_leaves", BambooLeafSize.SMALL)
            .mapping("large_leaves", BambooLeafSize.LARGE)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> LEVER = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(AttachmentType.CEILING, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(0, List.of(AttachmentType.CEILING, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .mapping(1, List.of(AttachmentType.WALL, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(2, List.of(AttachmentType.WALL, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(3, List.of(AttachmentType.WALL, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(4, List.of(AttachmentType.WALL, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(5, List.of(AttachmentType.FLOOR, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(5, List.of(AttachmentType.FLOOR, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(6, List.of(AttachmentType.FLOOR, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(6, List.of(AttachmentType.FLOOR, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .mapping(7, List.of(AttachmentType.CEILING, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(7, List.of(AttachmentType.CEILING, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(8, List.of(AttachmentType.CEILING, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(8, List.of(AttachmentType.CEILING, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(9, List.of(AttachmentType.WALL, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .mapping(10, List.of(AttachmentType.WALL, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(11, List.of(AttachmentType.WALL, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(12, List.of(AttachmentType.WALL, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(13, List.of(AttachmentType.FLOOR, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(13, List.of(AttachmentType.FLOOR, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(14, List.of(AttachmentType.FLOOR, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(14, List.of(AttachmentType.FLOOR, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(15, List.of(AttachmentType.CEILING, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(15, List.of(AttachmentType.CEILING, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .build();
    public static final TypeMapping<Integer, LightLevel> LIGHT = new TypeMapping.Builder<Integer, LightLevel>()
            .mapping(0, LightLevel._0)
            .mapping(1, LightLevel._1)
            .mapping(2, LightLevel._2)
            .mapping(3, LightLevel._3)
            .mapping(4, LightLevel._4)
            .mapping(5, LightLevel._5)
            .mapping(6, LightLevel._6)
            .mapping(7, LightLevel._7)
            .mapping(8, LightLevel._8)
            .mapping(9, LightLevel._9)
            .mapping(10, LightLevel._10)
            .mapping(11, LightLevel._11)
            .mapping(12, LightLevel._12)
            .mapping(13, LightLevel._13)
            .mapping(14, LightLevel._14)
            .mapping(15, LightLevel._15)
            .build();
    public static final TypeMapping<Integer, Moisture> MOISTURE = new TypeMapping.Builder<Integer, Moisture>()
            .mapping(0, Moisture._0)
            .mapping(1, Moisture._1)
            .mapping(2, Moisture._2)
            .mapping(3, Moisture._3)
            .mapping(4, Moisture._4)
            .mapping(5, Moisture._5)
            .mapping(6, Moisture._6)
            .mapping(7, Moisture._7)
            .build();
    public static final TypeMapping<Integer, Bool> MUSHROOM_FACE_BITS = new TypeMapping.Builder<Integer, Bool>()
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(3, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(1, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(2, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(9, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(6, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(7, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(8, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(4, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(5, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(3, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(3, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(3, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(0, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(1, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(1, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(1, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(2, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(2, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(2, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(9, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(9, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(9, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(0, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(6, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(6, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(6, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(7, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(7, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(7, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(8, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(8, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(8, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(4, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(4, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(4, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            // Pores only
            .mapping(13, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(12, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(11, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .build();
    public static final TypeMapping<Integer, Power> POWER = new TypeMapping.Builder<Integer, Power>()
            .mapping(0, Power._0)
            .mapping(1, Power._1)
            .mapping(2, Power._2)
            .mapping(3, Power._3)
            .mapping(4, Power._4)
            .mapping(5, Power._5)
            .mapping(6, Power._6)
            .mapping(7, Power._7)
            .mapping(8, Power._8)
            .mapping(9, Power._9)
            .mapping(10, Power._10)
            .mapping(11, Power._11)
            .mapping(12, Power._12)
            .mapping(13, Power._13)
            .mapping(14, Power._14)
            .mapping(15, Power._15)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> POWERED_RAIL = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(RailShapeStraight.NORTH_SOUTH, Bool.FALSE))
            .mapping(1, List.of(RailShapeStraight.EAST_WEST, Bool.FALSE))
            .mapping(2, List.of(RailShapeStraight.ASCENDING_EAST, Bool.FALSE))
            .mapping(3, List.of(RailShapeStraight.ASCENDING_WEST, Bool.FALSE))
            .mapping(4, List.of(RailShapeStraight.ASCENDING_NORTH, Bool.FALSE))
            .mapping(5, List.of(RailShapeStraight.ASCENDING_SOUTH, Bool.FALSE))
            .mapping(6, List.of(RailShapeStraight.NORTH_SOUTH, Bool.FALSE))
            .mapping(7, List.of(RailShapeStraight.NORTH_SOUTH, Bool.FALSE))
            .mapping(8, List.of(RailShapeStraight.NORTH_SOUTH, Bool.TRUE))
            .mapping(9, List.of(RailShapeStraight.EAST_WEST, Bool.TRUE))
            .mapping(10, List.of(RailShapeStraight.ASCENDING_EAST, Bool.TRUE))
            .mapping(11, List.of(RailShapeStraight.ASCENDING_WEST, Bool.TRUE))
            .mapping(12, List.of(RailShapeStraight.ASCENDING_NORTH, Bool.TRUE))
            .mapping(13, List.of(RailShapeStraight.ASCENDING_SOUTH, Bool.TRUE))
            .mapping(14, List.of(RailShapeStraight.NORTH_SOUTH, Bool.TRUE))
            .mapping(15, List.of(RailShapeStraight.NORTH_SOUTH, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, RailShape> RAIL_SHAPE = new TypeMapping.Builder<Integer, RailShape>()
            .mapping(0, RailShape.NORTH_SOUTH)
            .mapping(1, RailShape.EAST_WEST)
            .mapping(2, RailShape.ASCENDING_EAST)
            .mapping(3, RailShape.ASCENDING_WEST)
            .mapping(4, RailShape.ASCENDING_NORTH)
            .mapping(5, RailShape.ASCENDING_SOUTH)
            .mapping(6, RailShape.SOUTH_EAST)
            .mapping(7, RailShape.SOUTH_WEST)
            .mapping(8, RailShape.NORTH_WEST)
            .mapping(9, RailShape.NORTH_EAST)
            .mapping(10, RailShape.NORTH_SOUTH)
            .mapping(11, RailShape.EAST_WEST)
            .mapping(12, RailShape.ASCENDING_EAST)
            .mapping(13, RailShape.ASCENDING_WEST)
            .mapping(14, RailShape.ASCENDING_NORTH)
            .mapping(15, RailShape.ASCENDING_SOUTH)
            .build();
    public static final TypeMapping<Integer, Bool> REDSTONE_SIGNAL_TO_BOOL = new TypeMapping.Builder<Integer, Bool>()
            .mapping(0, Bool.FALSE)
            .mapping(1, Bool.TRUE)
            .mapping(2, Bool.TRUE)
            .mapping(3, Bool.TRUE)
            .mapping(4, Bool.TRUE)
            .mapping(5, Bool.TRUE)
            .mapping(6, Bool.TRUE)
            .mapping(7, Bool.TRUE)
            .mapping(8, Bool.TRUE)
            .mapping(9, Bool.TRUE)
            .mapping(10, Bool.TRUE)
            .mapping(11, Bool.TRUE)
            .mapping(12, Bool.TRUE)
            .mapping(13, Bool.TRUE)
            .mapping(14, Bool.TRUE)
            .mapping(15, Bool.TRUE)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> REPEATER = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirectionHorizontal.SOUTH, Delay._1))
            .mapping(1, List.of(FacingDirectionHorizontal.WEST, Delay._1))
            .mapping(2, List.of(FacingDirectionHorizontal.NORTH, Delay._1))
            .mapping(3, List.of(FacingDirectionHorizontal.EAST, Delay._1))
            .mapping(4, List.of(FacingDirectionHorizontal.SOUTH, Delay._2))
            .mapping(5, List.of(FacingDirectionHorizontal.WEST, Delay._2))
            .mapping(6, List.of(FacingDirectionHorizontal.NORTH, Delay._2))
            .mapping(7, List.of(FacingDirectionHorizontal.EAST, Delay._2))
            .mapping(8, List.of(FacingDirectionHorizontal.SOUTH, Delay._3))
            .mapping(9, List.of(FacingDirectionHorizontal.WEST, Delay._3))
            .mapping(10, List.of(FacingDirectionHorizontal.NORTH, Delay._3))
            .mapping(11, List.of(FacingDirectionHorizontal.EAST, Delay._3))
            .mapping(12, List.of(FacingDirectionHorizontal.SOUTH, Delay._4))
            .mapping(13, List.of(FacingDirectionHorizontal.WEST, Delay._4))
            .mapping(14, List.of(FacingDirectionHorizontal.NORTH, Delay._4))
            .mapping(15, List.of(FacingDirectionHorizontal.EAST, Delay._4))
            .build();
    public static final TypeMapping<Integer, Rotation> ROTATION = new TypeMapping.Builder<Integer, Rotation>()
            .mapping(0, Rotation._0)
            .mapping(1, Rotation._1)
            .mapping(2, Rotation._2)
            .mapping(3, Rotation._3)
            .mapping(4, Rotation._4)
            .mapping(5, Rotation._5)
            .mapping(6, Rotation._6)
            .mapping(7, Rotation._7)
            .mapping(8, Rotation._8)
            .mapping(9, Rotation._9)
            .mapping(10, Rotation._10)
            .mapping(11, Rotation._11)
            .mapping(12, Rotation._12)
            .mapping(13, Rotation._13)
            .mapping(14, Rotation._14)
            .mapping(15, Rotation._15)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> SCAFFOLDING = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(StabilityDistance._0, Bool.FALSE))
            .mapping(1, List.of(StabilityDistance._1, Bool.FALSE))
            .mapping(2, List.of(StabilityDistance._2, Bool.FALSE))
            .mapping(3, List.of(StabilityDistance._3, Bool.FALSE))
            .mapping(4, List.of(StabilityDistance._4, Bool.FALSE))
            .mapping(5, List.of(StabilityDistance._5, Bool.FALSE))
            .mapping(6, List.of(StabilityDistance._6, Bool.FALSE))
            .mapping(7, List.of(StabilityDistance._7, Bool.FALSE))
            .mapping(8, List.of(StabilityDistance._0, Bool.TRUE))
            .mapping(9, List.of(StabilityDistance._1, Bool.TRUE))
            .mapping(10, List.of(StabilityDistance._2, Bool.TRUE))
            .mapping(11, List.of(StabilityDistance._3, Bool.TRUE))
            .mapping(12, List.of(StabilityDistance._4, Bool.TRUE))
            .mapping(13, List.of(StabilityDistance._5, Bool.TRUE))
            .mapping(14, List.of(StabilityDistance._6, Bool.TRUE))
            .mapping(15, List.of(StabilityDistance._7, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> SEA_PICKLE = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Pickles._1, Bool.FALSE))
            .mapping(1, List.of(Pickles._2, Bool.FALSE))
            .mapping(2, List.of(Pickles._3, Bool.FALSE))
            .mapping(3, List.of(Pickles._4, Bool.FALSE))
            .mapping(4, List.of(Pickles._1, Bool.TRUE))
            .mapping(5, List.of(Pickles._2, Bool.TRUE))
            .mapping(6, List.of(Pickles._3, Bool.TRUE))
            .mapping(7, List.of(Pickles._4, Bool.TRUE))
            .build();
    public static final TypeMapping<String, SlabType> SLAB_TYPE = new TypeMapping.Builder<String, SlabType>()
            .mapping("top", SlabType.TOP)
            .mapping("bottom", SlabType.BOTTOM)
            .mapping("bottom", SlabType.DOUBLE)
            .build();
    public static final TypeMapping<Boolean, Stage> STAGE = new TypeMapping.Builder<Boolean, Stage>()
            .mapping(false, Stage._0)
            .mapping(true, Stage._1)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> STAIRS = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(FacingDirectionHorizontal.EAST, Half.BOTTOM))
            .mapping(1, List.of(FacingDirectionHorizontal.WEST, Half.BOTTOM))
            .mapping(2, List.of(FacingDirectionHorizontal.SOUTH, Half.BOTTOM))
            .mapping(3, List.of(FacingDirectionHorizontal.NORTH, Half.BOTTOM))
            .mapping(4, List.of(FacingDirectionHorizontal.EAST, Half.TOP))
            .mapping(5, List.of(FacingDirectionHorizontal.WEST, Half.TOP))
            .mapping(6, List.of(FacingDirectionHorizontal.SOUTH, Half.TOP))
            .mapping(7, List.of(FacingDirectionHorizontal.NORTH, Half.TOP))
            .build();
    public static final TypeMapping<Integer, StructureBlockMode> STRUCTURE_BLOCK_MODE = new TypeMapping.Builder<Integer, StructureBlockMode>()
            .mapping(0, StructureBlockMode.DATA)
            .mapping(1, StructureBlockMode.SAVE)
            .mapping(2, StructureBlockMode.LOAD)
            .mapping(3, StructureBlockMode.CORNER)
            .mapping(4, StructureBlockMode.INVALID)
            .mapping(5, StructureBlockMode.EXPORT)
            .mapping(6, StructureBlockMode.DATA)
            .mapping(7, StructureBlockMode.DATA)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> TNT = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE))
            .mapping(1, List.of(Bool.TRUE, Bool.FALSE))
            .mapping(2, List.of(Bool.FALSE, Bool.TRUE))
            .mapping(3, List.of(Bool.TRUE, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, FacingDirectionHorizontal> TORCH_FACING_DIRECTION = new TypeMapping.Builder<Integer, FacingDirectionHorizontal>()
            .mapping(3, FacingDirectionHorizontal.SOUTH)
            .mapping(2, FacingDirectionHorizontal.WEST)
            .mapping(4, FacingDirectionHorizontal.NORTH)
            .mapping(1, FacingDirectionHorizontal.EAST)
            .build();
    public static final TypeMapping<Integer, BlockStateValue> TRAPDOOR = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Half.BOTTOM, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(1, List.of(Half.BOTTOM, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(2, List.of(Half.BOTTOM, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(3, List.of(Half.BOTTOM, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(4, List.of(Half.TOP, FacingDirectionHorizontal.EAST, Bool.FALSE))
            .mapping(5, List.of(Half.TOP, FacingDirectionHorizontal.WEST, Bool.FALSE))
            .mapping(6, List.of(Half.TOP, FacingDirectionHorizontal.SOUTH, Bool.FALSE))
            .mapping(7, List.of(Half.TOP, FacingDirectionHorizontal.NORTH, Bool.FALSE))
            .mapping(8, List.of(Half.BOTTOM, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(9, List.of(Half.BOTTOM, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(10, List.of(Half.BOTTOM, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(11, List.of(Half.BOTTOM, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .mapping(12, List.of(Half.TOP, FacingDirectionHorizontal.EAST, Bool.TRUE))
            .mapping(13, List.of(Half.TOP, FacingDirectionHorizontal.WEST, Bool.TRUE))
            .mapping(14, List.of(Half.TOP, FacingDirectionHorizontal.SOUTH, Bool.TRUE))
            .mapping(15, List.of(Half.TOP, FacingDirectionHorizontal.NORTH, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> TRIPWIRE = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(1, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(2, List.of(Bool.FALSE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(3, List.of(Bool.FALSE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(4, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.FALSE))
            .mapping(5, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.FALSE))
            .mapping(6, List.of(Bool.TRUE, Bool.FALSE, Bool.FALSE, Bool.TRUE))
            .mapping(7, List.of(Bool.TRUE, Bool.FALSE, Bool.TRUE, Bool.TRUE))
            .mapping(8, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(9, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(10, List.of(Bool.FALSE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(11, List.of(Bool.FALSE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .mapping(12, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.FALSE))
            .mapping(13, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.FALSE))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, Bool.FALSE, Bool.TRUE))
            .mapping(15, List.of(Bool.TRUE, Bool.TRUE, Bool.TRUE, Bool.TRUE))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> TRIPWIRE_HOOK = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Bool.FALSE, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(1, List.of(Bool.FALSE, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(2, List.of(Bool.FALSE, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(3, List.of(Bool.FALSE, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(4, List.of(Bool.FALSE, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(5, List.of(Bool.FALSE, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(6, List.of(Bool.FALSE, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(7, List.of(Bool.FALSE, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .mapping(8, List.of(Bool.TRUE, Bool.FALSE, FacingDirectionHorizontal.SOUTH))
            .mapping(9, List.of(Bool.TRUE, Bool.FALSE, FacingDirectionHorizontal.WEST))
            .mapping(10, List.of(Bool.TRUE, Bool.FALSE, FacingDirectionHorizontal.NORTH))
            .mapping(11, List.of(Bool.TRUE, Bool.FALSE, FacingDirectionHorizontal.EAST))
            .mapping(12, List.of(Bool.TRUE, Bool.TRUE, FacingDirectionHorizontal.SOUTH))
            .mapping(13, List.of(Bool.TRUE, Bool.TRUE, FacingDirectionHorizontal.WEST))
            .mapping(14, List.of(Bool.TRUE, Bool.TRUE, FacingDirectionHorizontal.NORTH))
            .mapping(15, List.of(Bool.TRUE, Bool.TRUE, FacingDirectionHorizontal.EAST))
            .build();
    public static final TypeMapping<Integer, BlockStateValue> TURTLE_EGG = new TypeMapping.Builder<Integer, BlockStateValue>()
            .mapping(0, List.of(Eggs._1, Hatch._0))
            .mapping(1, List.of(Eggs._2, Hatch._0))
            .mapping(2, List.of(Eggs._3, Hatch._0))
            .mapping(3, List.of(Eggs._4, Hatch._0))
            .mapping(4, List.of(Eggs._1, Hatch._1))
            .mapping(5, List.of(Eggs._2, Hatch._1))
            .mapping(6, List.of(Eggs._3, Hatch._1))
            .mapping(7, List.of(Eggs._4, Hatch._1))
            .mapping(8, List.of(Eggs._1, Hatch._2))
            .mapping(9, List.of(Eggs._2, Hatch._2))
            .mapping(10, List.of(Eggs._3, Hatch._2))
            .mapping(11, List.of(Eggs._4, Hatch._2))
            .mapping(12, List.of(Eggs._1, Hatch._0))
            .mapping(13, List.of(Eggs._2, Hatch._0))
            .mapping(14, List.of(Eggs._3, Hatch._0))
            .mapping(15, List.of(Eggs._4, Hatch._0))
            .build();
}
